{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example Notebook\n",
    "\n",
    "This example Jupyter Notebook is designed to facilitate the process of loading data, setting up models, and running experiments for context-based question answering with `SelfElicit` and other baseline methods.\n",
    "It also showcases how to use the utility functions provided in this repository to run experiments across different datasets and models.\n",
    "\n",
    "You can change settings by modifying the `config.yaml` file.\n",
    "\n",
    "## Main Modules Used in this Example\n",
    "\n",
    "1. **args**:\n",
    "    - **get_args**: Function to retrieve and set up arguments for the notebook.\n",
    "  \n",
    "2. **dataloader**:\n",
    "    - **load_data**: Function to load datasets for the experiments.\n",
    "\n",
    "3. **utils**:\n",
    "    - **get_model_tokenizer_device**: Function to load the model, tokenizer, and device (e.g., GPU or CPU) for running the experiments.\n",
    "\n",
    "4. **qa_agent**:\n",
    "    - **get_agents_dict**: Function to prepare QA agent instances with different instructions.\n",
    "    - **ContextQuestionAnsweringAgent**: Class for handling context-based question answering tasks.\n",
    "\n",
    "5. **eval**:\n",
    "    - **evaluate**: Function to evaluate the model's answers against the true answers using metrics like F1 score and Exact Match (EM).\n",
    "\n",
    "6. **self_elicit**:\n",
    "    - **get_answer_base**: Function to get the base answer from the model.\n",
    "    - **get_answer_cot**: Function to get the answer using Chain-of-Thought (COT) reasoning.\n",
    "    - **get_answer_fullelicit**: Function to get the answer using full elicitation.\n",
    "    - **get_answer_promptelicit**: Function to get the answer using prompt elicitation.\n",
    "    - **get_answer_selfelicit**: Function to get the answer using self-elicit method.\n",
    "\n",
    "## Arguments (modifiable in `config.yaml`)\n",
    "\n",
    "| Argument            | Description                                                                          | Default (Valid Options)                                                                                                                                                                                                                                                                                                                                                  |\n",
    "| ------------------- | ------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n",
    "| `--hf_token`        | Hugging Face API token.                                                              | `\"your_hf_api_token\"` (Replace with your own token)                                                                                                                                                                                                                                                                                                                      |\n",
    "| `--model_id`        | The HuggingFace Model ID. Should be one of the specified models.                     | `\"meta-llama/Meta-Llama-3.1-8B-Instruct\"` (`\"meta-llama/Meta-Llama-3.1-70B-Instruct\"`, `\"mistralai/Mistral-7B-Instruct-v0.3\"`, `\"mistralai/Mistral-Nemo-Instruct-2407\"`, `\"Qwen/Qwen2.5-7B-Instruct\"`, `\"Qwen/Qwen2.5-32B-Instruct\"`)                                                                                                                                    |\n",
    "| `--methods`         | Method(s) to test. Can be a list or a single value.                                  | `[\"Base\", \"COT\", \"FullElicit\", \"PromptElicit\", \"SelfElicit\"]`                                                                                                                                                                                                                                                                                                            |\n",
    "| `--datasets`        | Dataset(s) to use. Can be a list or a single value.                                  | `[\"HotpotQA\", \"NewsQA\", \"TQA\", \"NQ\"]`                                                                                                                                                                                                                                                                                                                                    |\n",
    "| `--alpha`           | Threshold for the SelfElicit method.                                                 | 0.5                                                                                                                                                                                                                                                                                                                                                                      |\n",
    "| `--layer_span`      | A tuple representing the layer span for the SelfElicit method.                       | `(0.5, 1.0)` (Must be a tuple of two floats between [0, 1])                                                                                                                                                                                                                                                                                                              |\n",
    "| `--gpu_ids`         | List of GPU IDs to use for computation.                                              | `[0]` (Auto-detected if not specified)                                                                                                                                                                                                                                                                                                                                   |\n",
    "| `--n_samples`       | Number of samples in each dataset.                                                   | 1000 (Set to `None` to use the full data)                                                                                                                                                                                                                                                                                                                                |\n",
    "| `--random_state`    | The random state for reproducibility.                                                | 0                                                                                                                                                                                                                                                                                                                                                                        |\n",
    "| `--max_ans_tokens`  | Maximum length of the answer in tokens.                                              | 100                                                                                                                                                                                                                                                                                                                                                                      |\n",
    "| `--marker_impstart` | Marker indicating the start of important information in the context.                 | `\"<START_IMPORTANT>\"`                                                                                                                                                                                                                                                                                                                                                    |\n",
    "| `--marker_impend`   | Marker indicating the end of important information in the context.                   | `\"<END_IMPORTANT>\"`                                                                                                                                                                                                                                                                                                                                                      |\n",
    "| `--qa_inst`         | Instruction for context-based QA.                                                    | \"Directly answer the question based on the context passage, no explanation is needed. If the context does not contain any evidence, output 'I cannot answer based on the given context.'\"                                                                                                                                                                                |\n",
    "| `--se_inst`         | Instruction for context-based QA with SelfElicit highlighting. Must contain markers. | \"Directly answer the question based on the context passage, no explanation is needed. Within the context, {MARKER_IMPSTART} and {MARKER_IMPEND} are used to mark the important evidence. Read carefully but still keep your answer short, do not output the markers. If the context does not contain any evidence, output 'I cannot answer based on the given context.'\" |\n",
    "| `--cot_inst`        | Instruction for context-based QA with Chain-of-Thought (COT) prompting.              | \"Directly answer the question based on the context passage, no explanation is needed. If the context does not contain any evidence, output 'I cannot answer based on the given context.' Think step by step to provide the answer.\"                                                                                                                                      |\n",
    "| `--pe_inst`         | Instruction for extracting evidence from the context (1st step of PromptElicit).     | \"Please find the supporting evidence sentences from the context for the question, then copy-paste the original text to output without any additional words. Template for output: '\\n- [sentence1]\\n- [sentence2] ...'\"                                                                                                                                                   |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading default configuration from 'config.yaml' ...\n",
      "Parsing arguments from command line is disabled as using_notebook=True.\n",
      "Using GPUs: 0\n",
      "Arguments loaded successfully!\n",
      "Arguments:\n",
      "\thf_token  : *************************************\n",
      "\tmodel_id  : meta-llama/Meta-Llama-3.1-8B-Instruct\n",
      "\tmethods   : ['Base', 'COT', 'FullElicit', 'PromptElicit', 'SelfElicit']\n",
      "\tdatasets  : ['HotpotQA', 'NewsQA', 'TQA', 'NQ']\n",
      "\talpha     : 0.5\n",
      "\tlayer_span: (0.5, 1.0)\n",
      "\tgpu_ids   : [0]\n",
      "\tn_samples : 1000\n",
      "\trandom_state: 0\n",
      "\tmax_ans_tokens: 100\n",
      "\tmarker_impstart: <START_IMPORTANT>\n",
      "\tmarker_impend: <END_IMPORTANT>\n",
      "\tqa_inst   : Directly answer the question based on the context passage, no explanation is needed. If the context does not contain any evidence, output 'I cannot answer based on the given context.'\n",
      "\tse_inst   : Directly answer the question based on the context passage, no explanation is needed. Within the context, <START_IMPORTANT> and <END_IMPORTANT> are used to mark the important evidence. Read carefully but still keep your answer short, do not output the markers. If the context does not contain any evidence, output 'I cannot answer based on the given context.'\n",
      "\tcot_inst  : Directly answer the question based on the context passage, no explanation is needed. If the context does not contain any evidence, output 'I cannot answer based on the given context.' Think step by step to provide the answer.\n",
      "\tpe_inst   : Please find the supporting evidence sentences from the context for the question, then copy-paste the original text to output without any additional words. Template for output: '\n",
      "- [sentence1]\n",
      "- [sentence2] ...'\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "1. Get the arguments and set up the GPUs (done in the `get_args` function)\n",
    "\"\"\"\n",
    "\n",
    "from args import get_args\n",
    "\n",
    "args = get_args(using_notebook=True)\n",
    "\n",
    "args.n_samples = 200  # setting this for quick testing on a small subset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CUDA is available with devices:\n",
      "\t- Device 0: NVIDIA A100-SXM4-80GB\n",
      "Logging in to Hugging Face ...\n",
      "The token has not been saved to the git credentials helper. Pass `add_to_git_credential=True` in this function directly or `--add-to-git-credential` if using via `huggingface-cli` if you want to set the git credential as well.\n",
      "Token is valid (permission: write).\n",
      "Your token has been saved to /home/liu326/.cache/huggingface/token\n",
      "Login successful\n",
      "Loading model and tokenizer ... "
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9fa2ec74119140f8a8f928f045b94336",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Loading checkpoint shards:   0%|          | 0/4 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'qa': <qa_agent.ContextQuestionAnsweringAgent at 0x7f2d51deb610>,\n",
       " 'se': <qa_agent.ContextQuestionAnsweringAgent at 0x7f2c70441b20>,\n",
       " 'cot': <qa_agent.ContextQuestionAnsweringAgent at 0x7f2c5d6e6460>,\n",
       " 'pe': <qa_agent.ContextQuestionAnsweringAgent at 0x7f2c5d6f1790>}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "2. Prepare the model and tokenizer, set up the QA agents\n",
    "\"\"\"\n",
    "\n",
    "from utils import get_model_tokenizer_device\n",
    "from qa_agent import get_agents_dict, ContextQuestionAnsweringAgent\n",
    "\n",
    "# Load model, tokenizer, and devices\n",
    "model, tokenizer, device = get_model_tokenizer_device(args.hf_token, args.model_id)\n",
    "# Prepare QA agent instances (with different instructions)\n",
    "agents_dict = get_agents_dict(model, tokenizer, device, args)\n",
    "agents_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run Experiment\n",
    "The following `run_experiment` function orchestrates the entire experiment process, including loading datasets, running different methods to get answers, and evaluating the results. The results are compiled into a pandas DataFrame for further analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading the HotpotQA dataset ... Success!\n",
      "Loading the NewsQA dataset ... Success!\n",
      "Loading the TriviaQA-web dataset ... Success!\n",
      "Loading the NaturalQuestionsShort dataset ... Success!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "DATA - HotpotQA  :   0%|          | 0/200 [00:00<?, ?it/s]LlamaModel is using LlamaSdpaAttention, but `torch.nn.functional.scaled_dot_product_attention` does not support `output_attentions=True`. Falling back to the manual attention implementation, but specifying the manual implementation will be required from Transformers version v5.0.0 onwards. This warning can be removed using the argument `attn_implementation=\"eager\"` when loading the model.\n",
      "We detected that you are passing `past_key_values` as a tuple and this is deprecated and will be removed in v4.43. Please use an appropriate `Cache` class (https://huggingface.co/docs/transformers/v4.41.3/en/internal/generation_utils#transformers.Cache)\n",
      "DATA - HotpotQA  : 100%|██████████| 200/200 [07:24<00:00,  2.22s/it, f1={'Base': 60.34, 'COT': 60.55, 'FullElicit': 60.7, 'PromptElicit': 65.29, 'SelfElicit': 67.87}, em={'Base': 61.5, 'COT': 62.5, 'FullElicit': 61.0, 'PromptElicit': 66.5, 'SelfElicit': 67.84}]     \n",
      "DATA - NewsQA    : 100%|██████████| 200/200 [10:41<00:00,  3.21s/it, f1={'Base': 56.77, 'COT': 56.41, 'FullElicit': 57.74, 'PromptElicit': 58.01, 'SelfElicit': 61.06}, em={'Base': 67.0, 'COT': 66.5, 'FullElicit': 68.0, 'PromptElicit': 64.0, 'SelfElicit': 69.0}]     \n",
      "DATA - TQA       : 100%|██████████| 200/200 [11:22<00:00,  3.41s/it, f1={'Base': 65.22, 'COT': 66.77, 'FullElicit': 65.32, 'PromptElicit': 70.2, 'SelfElicit': 70.11}, em={'Base': 70.0, 'COT': 72.0, 'FullElicit': 71.0, 'PromptElicit': 75.0, 'SelfElicit': 75.0}]      \n",
      "DATA - NQ        : 100%|██████████| 200/200 [07:59<00:00,  2.40s/it, f1={'Base': 59.2, 'COT': 59.64, 'FullElicit': 59.64, 'PromptElicit': 65.47, 'SelfElicit': 66.03}, em={'Base': 59.0, 'COT': 59.5, 'FullElicit': 59.5, 'PromptElicit': 59.5, 'SelfElicit': 63.0}]      \n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "3. Run the experiment\n",
    "\"\"\"\n",
    "\n",
    "import tqdm\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from eval import evaluate\n",
    "from dataloader import load_data\n",
    "from self_elicit import (\n",
    "    get_answer_base,\n",
    "    get_answer_cot,\n",
    "    get_answer_fullelicit,\n",
    "    get_answer_promptelicit,\n",
    "    get_answer_selfelicit,\n",
    ")\n",
    "import warnings\n",
    "\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "\n",
    "def run_experiment(device, agents_dict, args):\n",
    "\n",
    "    methods = args.methods\n",
    "    datasets_dict = {\n",
    "        dataset: load_data(dataset, args.n_samples, args.random_state, True)\n",
    "        for dataset in args.datasets\n",
    "    }\n",
    "    qa_res_eval_cols = [\n",
    "        \"em\",\n",
    "        \"f1\",\n",
    "        \"pr\",\n",
    "        \"re\",\n",
    "    ]\n",
    "    qa_res_columns = [\n",
    "        \"dataset\",\n",
    "        \"idx\",\n",
    "        \"true_ans\",\n",
    "        \"model_ans\",\n",
    "        \"method\",\n",
    "    ] + qa_res_eval_cols\n",
    "\n",
    "    qa_results = []\n",
    "\n",
    "    for dataset_name, dataset in datasets_dict.items():\n",
    "\n",
    "        dataset_runstat = {\n",
    "            \"f1\": {method: [] for method in methods},\n",
    "            \"em\": {method: [] for method in methods},\n",
    "        }\n",
    "\n",
    "        iterator = tqdm.tqdm(range(len(dataset)), desc=f\"DATA - {dataset_name:<10s}\")\n",
    "        for idx in iterator:\n",
    "            context, question, true_ans_list = dataset.get_context_question_answer(idx)\n",
    "\n",
    "            for method in methods:\n",
    "                try:\n",
    "                    if method == \"Base\":\n",
    "                        model_ans = get_answer_base(\n",
    "                            context, question, agents_dict, args\n",
    "                        )\n",
    "                    elif method == \"COT\":\n",
    "                        model_ans = get_answer_cot(context, question, agents_dict, args)\n",
    "                    elif method == \"FullElicit\":\n",
    "                        model_ans = get_answer_fullelicit(\n",
    "                            context, question, agents_dict, args\n",
    "                        )\n",
    "                    elif method == \"PromptElicit\":\n",
    "                        model_ans = get_answer_promptelicit(\n",
    "                            context, question, agents_dict, args\n",
    "                        )\n",
    "                    elif method == \"SelfElicit\":\n",
    "                        model_ans, evidence_sents = get_answer_selfelicit(\n",
    "                            context,\n",
    "                            question,\n",
    "                            agents_dict,\n",
    "                            device,\n",
    "                            args,\n",
    "                            return_evidence=True,\n",
    "                        )\n",
    "                except:\n",
    "                    continue\n",
    "\n",
    "                true_ans_used, scores = evaluate(\n",
    "                    true_ans_list, model_ans, sel_metric=\"f1\"\n",
    "                )\n",
    "\n",
    "                qa_results.append(\n",
    "                    [\n",
    "                        dataset_name,\n",
    "                        idx,\n",
    "                        true_ans_used,\n",
    "                        model_ans,\n",
    "                        method,\n",
    "                    ]\n",
    "                    + [scores[col] for col in qa_res_eval_cols]\n",
    "                )\n",
    "\n",
    "                dataset_runstat[\"f1\"][method].append(scores[\"f1\"] * 100)\n",
    "                dataset_runstat[\"em\"][method].append(scores[\"em\"] * 100)\n",
    "\n",
    "            iterator.set_postfix(\n",
    "                {\n",
    "                    \"f1\": {\n",
    "                        method: np.mean(dataset_runstat[\"f1\"][method]).round(2)\n",
    "                        for method in methods\n",
    "                    },\n",
    "                    \"em\": {\n",
    "                        method: np.mean(dataset_runstat[\"em\"][method]).round(2)\n",
    "                        for method in methods\n",
    "                    },\n",
    "                }\n",
    "            )\n",
    "\n",
    "    qa_results = pd.DataFrame(qa_results, columns=qa_res_columns)\n",
    "    return qa_results\n",
    "\n",
    "\n",
    "qa_results = run_experiment(device, agents_dict, args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"\n",
    "4. Visualize the results\n",
    "\"\"\"\n",
    "\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "sns.set(style=\"whitegrid\")\n",
    "\n",
    "metrics = [\"f1\", \"em\"]\n",
    "\n",
    "fig, axes = plt.subplots(1, len(metrics), figsize=(15, 5))\n",
    "\n",
    "for i, metric in enumerate(metrics):\n",
    "    ax = sns.barplot(\n",
    "        x=\"dataset\",\n",
    "        hue=\"method\",\n",
    "        y=metric,\n",
    "        data=qa_results,\n",
    "        ax=axes[i],\n",
    "        ci=False,\n",
    "    )\n",
    "    ax.legend(loc=\"lower right\")\n",
    "    ax.set_title(f\"Metric: {metric.upper()}\")\n",
    "    ax.set_ylim(0.5, ax.get_ylim()[1])\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save results\n",
    "\n",
    "The results are saved in a CSV file for further analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving results to results/exp_[MODEL]meta-llama|Meta-Llama-3.1-8B-Instruct_[METHOD]Base-COT-FullElicit-PromptElicit-SelfElicit_[DATA]HotpotQA-NewsQA-TQA-NQ.csv ...Success!\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "5. Save the results for future analysis\n",
    "\"\"\"\n",
    "\n",
    "path = f\"results/exp_[MODEL]{args.model_id.replace('/', '|')}_[METHOD]{'-'.join(args.methods)}_[DATA]{'-'.join(args.datasets)}.csv\"\n",
    "print(f\"Saving results to {path} ...\", end=\"\")\n",
    "qa_results.to_csv(path, index=False)\n",
    "print(\"Success!\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
